package com.ia.aistream.manager.dxfcomponent.util;

import com.ia.aistream.manager.dxfcomponent.conf.DrawMapConf;
import com.ia.aistream.model.dxfcomponent.entity.DxfComponent;
import com.ia.aistream.model.dxfcomponent.entity.DxfDraw;
import com.ia.aistream.model.dxfcomponent.entity.FileComponent;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/****
 * 实现dxf文件的读取，并且获取MTEXT类型的数据
 * @author ymj
 */
public class FileUtilTest {

    /**
     * 将构造方法私有化，防止实例的生成
     */
    private FileUtilTest() { }

    /***
     * 将原始dxf文件读到内存中
     */
    public synchronized static List<String> readDxfDataSource(String filePath) {
        String format =".dxf";
        //验证文件格式是否符合，如果不符合则返回空
        if(filePath==null || "".equals(filePath) || !filePath.endsWith(format)){
            return null;
        }
        try{
            Charset charset= Charset.forName("UTF-8");
            File file = new File(filePath);
            int index = 0;
            while(!file.exists()){

                Thread.sleep(1000);
                if(index==15){
                    break;
                }
                index++;
            }
            //通过NIO的方式，将所有的数据读取到内存中
            List<String> fileStr = Files.readAllLines(Paths.get(filePath), charset);
            //将读取到的文件数据返回
            return fileStr;
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
            return null;
        }
    }

    /***
     * 获取上传图纸的大小
     * 获取图纸的左上和右下角坐标
     * @param filterLayer  删除掉隐藏图层后的数据
     */
    public static double[] drawSize(List<String> filterLayer){
        try{
            double[] result = new double[7];
//
//            double width = 0.0;
//            double height = 0.0;
            // 获取图纸的大小
            String[] drawSize = getDrawSize(filterLayer);

            // 获取需要数据的位置
            String flag = drawSize[6];
            double xH = Double.parseDouble(drawSize[0]);
            double xG = Double.parseDouble(drawSize[1]);
            double y8 = Double.parseDouble(drawSize[2]);
            double y7 = Double.parseDouble(drawSize[3]);
            double xA = Double.parseDouble(drawSize[4]);
            double y1 = Double.parseDouble(drawSize[5]);
//            double countX = Integer.parseInt(drawSize[7]);
//            double countY = Integer.parseInt(drawSize[8]);

            double wX = 0.0;
            double hY = 0.0;
            // 获取图幅的大小
//            if(flag.equals("H")){
//                width = Math.abs(xH - xG)*countX;
//
//                height = Math.abs(y8 - y7)*countY;
//            }else {
//                width = Math.abs(y8 - y7)*countX;
//              //  wX = Math.abs(y8 - y7);
//                height = Math.abs(xH - xG)*countY;
//              //  hY = Math.abs(xH - xG);
//            }
            wX = Math.abs(xH - xG);
            hY = Math.abs(y8 - y7);

//            double sX = 0.0;
//            double sY = 0.0;
            double leftTopX = 0.0;
            double leftTopY = 0.0;
            double rightBottomX = 0.0;
            double rightBottomY = 0.0;
            if(xH > xA){
                double x = xA;
                xA = xH;
                xH = x;
            }
            if(y1 > y8){
                double y = y1;
                y1 = y8;
                y8 = y;
            }

            if(flag.equals("H")){
                leftTopX = xH - wX;
                leftTopY = y8 + hY;
                rightBottomX = xA + wX;
                rightBottomY = y1 - hY;
            }else {
                leftTopX = y1 - hY;
                leftTopY = xA + wX;
                rightBottomX = y8 + hY;
                rightBottomY = xH - wX;
            }


            result[0] = leftTopX;
            result[1] = leftTopY;
            result[2] = rightBottomX;
            result[3] = rightBottomY;

//
//            if(flag.equals("H")){
//                leftTopX = xH - wX;
//                leftTopY = y8 + hY;
//                rightBottomX = xA + wX;
//                rightBottomY = y1 - hY;
//            }else{
//                leftTopX = xH - wX;
//                leftTopY = y8 + hY;
//                rightBottomX = xA + wX;
//                rightBottomY = y1 - hY;
//            }


//            System.out.println("leftTopX=" + leftTopX);
//            System.out.println("leftTopY=" + leftTopY);
//            System.out.println("rightBottomX=" + rightBottomX);
//            System.out.println("rightBottomY=" + rightBottomY);
            // 获取横向的图幅大小
//            if(flag.equals("H")){
//                // 获取比例
//                double xmode = Math.round(6400/width);
//
//                // 处理6400大小以上的数据
//                if(xmode==0.0){
//                    double round = Math.round(width / 20000);
//                    // 如果小于20000，则正常放大
//                    if(round < 1.0){
//                        sX = width;
//                        sY = height;
//                        leftTopX = xH - 1660;
//                        leftTopY = y8 + 1360;
//                        rightBottomX = xA + 1660;
//                        rightBottomY = y1 - 1360;
//                    }else{
//                        sX = width/round;
//                        sY = height/round;
//                        leftTopX = xH - 2700 * round;
//                        leftTopY = y8 + 1710 * round;
//                        rightBottomX = xA + 4000 * round;
//                        rightBottomY = y1 - 3000 * round;
//                    }
//                    result[6] = round;
//                }else{
//                    sX = xmode * width;
//                    sY = xmode * height;
//                    leftTopX = xH - 700 / xmode;
//                    leftTopY = y8 + 600 / xmode;
//                    rightBottomX = xA + 700 / xmode;
//                    rightBottomY = y1 - 600 / xmode;
//                    result[6] = xmode;
//                }
//            }else{
//                // 获取比例
//                double xmode = Math.round(6400/height);
//
//                // 处理6400大小以上的数据
//                if(xmode==0.0){
//                    double round = Math.round(height / 20000);
//                    // 如果小于20000，则正常放大
//                    if(round < 1.0){
//                        sX = width;
//                        sY = height;
//                        leftTopX = y1 - 1660;
//                        leftTopY = xA + 1360;
//                        rightBottomX = y8 + 1660;
//                        rightBottomY = xH - 1360;
//                    }else{
//                        sX = width/round;
//                        sY = height/round;
//                        leftTopX = y1 - 1510 * round;
//                        leftTopY = xA + 1810 * round;
//                        rightBottomX = y8 + 1510 * round;
//                        rightBottomY = xH - 1810 * round;
//                    }
//                    result[6] = round;
//                }else{
//                    sX = xmode * width;
//                    sY = xmode * height;
//                    leftTopX = y1 - 700 / xmode;
//                    leftTopY = xA + 800 / xmode;
//                    rightBottomX = y8 + 800 / xmode;
//                    rightBottomY = xH - 900 / xmode;
//
//                    result[6] = xmode;
//                }
//            }

//            if(sX > 1.0){
//                result[0] = sX;
//                result[1] = sY;
//                result[2] = leftTopX;
//                result[3] = leftTopY;
//                result[4] = rightBottomX;
//                result[5] = rightBottomY;
//            }

            return result;
        }catch(Exception e){
            return null;
        }
    }

    /***
     * 实现获取图纸的宽和高
     * 获取图纸的起点和终点
     * @param list
     * @return
     */
    private static String[] getDrawSize(List<String> list){
        String[] str = new String[7];
        String zX = "";
        String zY = "";
        String hX = "";
        String hY = "";
        String gX = "";
        String gY = "";
        String aX = "";
        String aY = "";
        String y8 = "";
        String x8 = "";
        String x7 = "";
        String y7 = "";
        String x1 = "";
        String y1 = "";
        String dX = "";
        String dY = "";
        String cX = "";
        String cY = "";
        String x5 = "";
        String y5 = "";
        String y6 = "";
        String x6 = "";
        String fX = "";
        String fY = "";
        String eX = "";
        String eY = "";

        boolean start = false;
        boolean startFlag = false;
        boolean flag = false;
        String fl = "";
        int index = -2;
        for(String s : list){
            // 获取H、G的X轴坐标
            // 获取7、8的Y轴坐标
            if("ENTITIES".equals(s)){
                start = true;
            }
            if ("OBJECTS".equals(s)){
                start = false;
            }
            if(start) {
                if ("  0".equals(s)) {
                    index = 1;
                } else if (index == 1 && readType(s)) {
                    startFlag = true;
                    index = 0;
                } else if (startFlag && " 10".equals(s)) {
                    flag = true;
                    fl = "10";
                } else if (flag && "10".equals(fl)) {
                    zX = s;
                    flag = false;
                } else if (startFlag && " 20".equals(s)) {
                    flag = true;
                    fl = "20";
                } else if (flag && "20".equals(fl)) {
                    zY = s;
                    flag = false;
                } else if (startFlag && "  1".equals(s)) {
                    flag = true;
                    fl = "1";
                } else if (flag && "1".equals(fl)) {
                    if (s.contains(";")) {
                        s = s.substring(s.lastIndexOf(";") + 1);
                    }
                    s = s.trim();
                    s = DrawExtensionUtil.handleOriginal(s);
                    switch (s) {// Double.parseDouble(zX) > Double.parseDouble(hX) &&
                        case "H":
                            if ("".equals(hX) || ( Double.parseDouble(zY) < Double.parseDouble(hY))) {
                                hX = zX;
                                hY = zY;
                            }
                            break;
                        case "G": // Double.parseDouble(zX) > Double.parseDouble(gX) &&
                            if ("".equals(gX) || ( Double.parseDouble(zY) > Double.parseDouble(gY))) {
                                gX = zX;
                                gY = zY;
                            }
                            break;
                        case "F":
                            if("".equals(fX) || Double.parseDouble(zX) < Double.parseDouble(fX)){
                                fX = zX;
                                fY = zY;
                            }
                            break;
                        case "E":
                            if("".equals(eX) || Double.parseDouble(zX) < Double.parseDouble(eX)){
                                eX = zX;
                                eY = zY;
                            }
                            break;
                        case "D":
                            if("".equals(dX) || Double.parseDouble(zX) < Double.parseDouble(dX)){
                                dX = zX;
                                dY = zY;
                            }
                            break;
                        case "C":
                            if ("".equals(cX) || Double.parseDouble(zX) > Double.parseDouble(cX)) {
                                cX = zX;
                                cY = zY;
                            }
                            break;
                        case "A":
                            // Double.parseDouble(zX) > Double.parseDouble(aX) &&
                            if ("".equals(aX) || (Double.parseDouble(zY) > Double.parseDouble(aY))) {
                                aX = zX;
                                aY = zY;
                            }
                            break;
                        case "8":
                            // && Double.parseDouble(zY) > Double.parseDouble(y8)
                            if ("".equals(y8) || (Double.parseDouble(zX) > Double.parseDouble(x8))) {
                                x8 = zX;
                                y8 = zY;
                            }
                            break;
                        case "7":
                            // && Double.parseDouble(zY) > Double.parseDouble(y7)
                            if ("".equals(y7) || (Double.parseDouble(zX) > Double.parseDouble(x7) )) {
                                y7 = zY;
                                x7 = zX;
                            }
                            break;
                        case "6":
                            if ("".equals(y6) || Double.parseDouble(zX) < Double.parseDouble(x6)) {
                                y6 = zY;
                                x6 = zX;
                            }
                            break;
                        case "5":
                            if ("".equals(y5) || Double.parseDouble(zX) < Double.parseDouble(x5)) {
                                y5 = zY;
                                x5 = zX;
                            }
                            break;
                        case "1":
                            // Double.parseDouble(zY) < Double.parseDouble(y1) &&
                            if ("".equals(y1) || (Double.parseDouble(zX) > Double.parseDouble(x1))) {
                                y1 = zY;
                                x1 = zX;
                            }
                            break;
                    }
                    flag = false;
                } else if (index == 1 && !"TEXT".equals(s)) {
                    index = 0;
                }
            }
        }

        try{
//            String countX = "8";
//            String countY = "8";
            if(x7.equals("")){
                x8 = x6;
                y8 = y6;
                x7 = x5;
                y7 = y5;
//                countY = "6";
            }else if(x8.equals("")){
                x8 = x7;
                y8 = y7;
                x7 = x6;
                y7 = y6;
//                countY = "7";
            }

            if(gX.equals("")){
               hX = fX;
               hY = fY;
               gX = eX;
               gY = eY;
//               countX = "6";
            }else if(hX.equals("")){
                hX = gX;
                hY = gY;
                gX = fX;
                gY = fY;
//                countX = "7";
            }
            double xAbs = Math.abs(Double.parseDouble(x8) - Double.parseDouble(x7));

            if(hX.equals("") && gX.equals("")){
                hX = dX;
                gX = cX;
                hY = dY;
                gY = cY;
//                countX = "4";
            }
            double width = Math.abs(Double.parseDouble(hX) - Double.parseDouble(aX));
            // 处理横坐标的情况
            if(xAbs < 0.1 * width){
                str[2] = y8;
                str[3] = y7;
                str[5] = y1;
                str[0] = hX;
                str[1] = gX;
                str[4] = aX;
                str[6] = "H";
//                str[7] = countX;
//                str[8] = countY;
            }else{
                str[2] = x8;
                str[3] = x7;
                str[5] = x1;
                str[0] = hY;
                str[1] = gY;
                str[4] = aY;
                str[6] = "S";
//                str[7] = countY;
//                str[8] = countX;
            }

        }catch (NumberFormatException ex){
            return null;
        }

        return str;
    }

    /****
     * 将内部调用方法进行封装，对外提供简单的方法,返回设备信息
     * @param filePath
     * @return
     */
    public static Map<String,Object> getDxfResultEquipment(String filePath){
        //获取文件的资源，判断文件的资源是否为空
        List<String> sources = readDxfDataSource(filePath);
        if(sources!=null){
            //返回的结果不为空，则提取数据
            List<FileComponent> fileComponents = readDxfComponent(sources);
            if(fileComponents!=null && fileComponents.size()>0){
                Map<String, Object> map = getDxfComponentEquipment(fileComponents);
                return map;
            }
        }
        return null;
    }

    /***
     * 获取图纸中的索引数据
     * @param filePath
     * @return
     */
   public static DxfDraw getDrawIndexResult(String filePath){
        //获取dxf文件中的原始数据
       List<String> stringList = readDxfDataSource(filePath);

       //将dxf文件中的数据封装到FileComponent中
       List<FileComponent> fileComponentList = readDxfComponent(stringList);

      return getDrawIndex(fileComponentList);
   }

    /***
     * *******************************
     * 获取图纸中的设备数据
     * @param filePath
     * @return
     */
    public static List<DxfComponent> getDrawComponentResult(String filePath){
        //获取dxf文件中的原始数据
        List<String> stringList = readDxfDataSource(filePath);

        //将dxf文件中的数据封装到FileComponent中
        List<FileComponent> fileComponentList = readDxfComponent(stringList);

        return getDrawComponent(fileComponentList);
    }

    /***
     * 将内部调用方法进行封装，对外提供简单的方法
     * 获取上传dxf文件，处理后的结果
     * @param filePath
     * @return
     */
    public static Map<String,Object> getDxfResult(String filePath){
        //获取文件的资源，判断文件的资源是否为空
        List<String> sources = readDxfDataSource(filePath);
        if(sources!=null){
            //返回的结果不为空，则提取数据
            List<FileComponent> fileComponents = readDxfComponent(sources);
            if(fileComponents!=null && fileComponents.size()>0){
                Map<String, Object> map = getDxfComponent(fileComponents);
                return map;
            }
        }
        return null;
    }

    /***
     * 使用NIO将本地文件缓存到内存中，并将MTEXT信息封装到FileComponent对象中
     */
    private static List<FileComponent> readDxfComponent(List<String> fileStr){

        if(fileStr == null){
            return null;
        }

        //定义集合，存放所有设备相关的信息
        List<FileComponent> list = new ArrayList<>();

        /***
         * 定义读取数据的规则：
         *      1、以“  0”开始。
         *      2、下一行的值为MTXET。
         *      3、 开始读取数据内容
         *      4、 以" 44"结尾，开始读取下一次的内容
         * 备注  5、若是以后出现44提出数据错误，则以 1、为一次提取数据结束
         */
        //记录上一行为需要获取数据的key
        boolean flag=false;
        //记录开始获取的位置：0   MTEXT
        boolean startFlag=false;
        //记录数据存放到对象的哪个属性中
        String fl="";
        //记录开始位置
        int start=0;
        boolean txFlag = false;
        String txFl ="";

        // 判断类型是MTEXT 还是TEXT
        String flagText = "";
        //声明对象
        FileComponent dx=null;
        //循环遍历所有的字符串
        for(String s:fileStr){
//            System.out.println("+++==" + s);
            //验证开始位置
            if("  0".equals(s)){
                //将计数器设置为1
                start = 1;
                if(dx!=null && !list.contains(dx)){

                    list.add(dx);
                }
            }else if(readType(s) && start==1){
                //字符串为MTEXT，并且start为1
                //开始进行数据的存储
                startFlag=true;
                //将记录位置重置为0
                start=0;
                //创建存在MTEXT属性的对象
                dx = new FileComponent();
            }else if (startFlag && "  8".equals(s)){
                //获取图层信息数据

                flag=true;
                fl="8";
            }else if (startFlag && "  1".equals(s)){
                //文本的标识，表示下一行数据为文本

                flag=true;
                fl="1";
            }else if (startFlag && "  7".equals(s)){
                //获取文字的样式

                flag=true;
                fl="7";
            }else if(startFlag && " 10".equals(s)){
                //获取对象的X坐标

                flag=true;
                fl="10";
            }else if(startFlag && " 20".equals(s)){
                //获取对象的Y坐标

                flag=true;
                fl="20";
            }else if(flag && "8".equals(fl)){
                //如果fl属性为8，保存图层名称

                dx.setLayer(s);
                flag=false;
            }else if(flag && "1".equals(fl)){
                //如果fl属性为1，保存文本信息
                dx.setOriginal(s);
                flag=false;
            }else if(flag && "7".equals(fl)){
                //保存文字样式

                dx.setStyle(s);
                flag=false;
                startFlag = false;
//                list.add(dx);
            }else if(flag && "10".equals(fl)){
                dx.setX(Double.parseDouble(s));
                flag=false;
            }else if(flag && "20".equals(fl)){
                dx.setY(Double.parseDouble(s));
                flag=false;
            }else if(!readType(s) && start==1){
                start=0;
            }


//            // 进行TEXT文件的处理
//            if("  0".equals(s)){
//
//                //将计数器设置为1
//                start = 1;
//            }else if("TEXT".equals(s) && start==1){
//                txFlag=true;
//            }else if(txFlag && "  8".equals(s)){
//                txFl = "8";
//            }else if(txFlag && " 10".equals(s)){
//                txFl = "10";
//            }else if(txFlag && " 20".equals(s)){
//                txFl = "20";
//            }else if(txFlag && "  1".equals(s)){
//                txFl = "1";
//            }else if (txFlag && "  7".equals(s)){
//                txFl = "7";
//            }
        }

        return list;
    }


    /***
     * 获取文件中的索引信息（标题栏）
     * @param list
     * @return
     */
    private static DxfDraw getDrawIndex(List<FileComponent> list){

        //判断集合是否为空，为空则返回null值
        if(list==null || list.size()==0){
            return null;
        }

        //创建索引信息的对象
        DxfDraw titleBar = new DxfDraw();

        //遍历原始数据
        for (FileComponent fc : list){
            //获取原始数据
            String content = fc.getOriginal();
            //如果字符串长度小于2位则直接跳过本次循环
            if(content.length()<2){
                continue;
            }
            //处理原始数据，获取需要的值
            String tb = handleComponentName(content);
            if(tb.contains("图") && handleFileName(tb)){
                titleBar.setFileName(tb);
            }
            if(tb.startsWith("FQ") && tb.length()>10){
                titleBar.setFileCode(tb);
            }
            //处理标题栏数据
            if("设备标注文字".equals(fc.getStyle())){

                //对数据进行规则验证，判断是否是图纸编号
                if(tb.startsWith("FQ") && tb.length()>10){

                    titleBar.setFileCode(tb);
                }else if(handleSystem(tb)){
                    //判断是否是系统值
                    titleBar.setSystem(tb);
                }else if(handleSubItem(tb)){
                    //验证是否是子项值
                    titleBar.setSubitem(tb);
                }else if(handleFileName(tb)){
                    //判断是否是文件名称
                    titleBar.setFileName(tb);
                }else if(handleVersion(tb)){
                    //验证是否是版本
                    titleBar.setVersion(tb);
                }else if(handleEdition(tb)){
                    //验证是否是版次
                    titleBar.setEdition(tb);
                }
            }
        }

        return titleBar;
    }

    /**
     * 采用***************************
     * 获取DXF文件中的所有设备信息
     * @param list
     * @return
     */
    private static List<DxfComponent> getDrawComponent(List<FileComponent> list){

        //判断集合是否为空，为空则返回null值
        if(list==null || list.size()==0){
            return null;
        }

        //创建部件的集合
        List<DxfComponent> dxfComponentList = new ArrayList<>();

        //遍历原始数据进行处理
        for (FileComponent fc : list){
            //声明对象，存储提取到的元素
            DxfComponent dxfComponent = new DxfComponent();

            //获取原始数据
            String content = fc.getOriginal();

            //如果当前循环的字符串长度只有一位，那么直接跳过本次循环
            if(content.length()<2){
                continue;
            }

            //对数据进行处理
            String subString = handleComponentName(content);

            //保存处理标题栏的数据
            String tb = subString;
            //验证字符串是否是设备信息
            if (handleEquipmentCode(subString)){

                dxfComponent.setContentC(subString);
                //存储部件的类型
                dxfComponent.setType("E");
                //保存原始数据
                dxfComponent.setContentO(content);
                //保存图层数据
                dxfComponent.setLayer(fc.getLayer());
                //获取每个点对应的坐标
                dxfComponent.setPositionX(fc.getX());
                dxfComponent.setPositionY(fc.getY());

                dxfComponentList.add(dxfComponent);
            }
        }

        return dxfComponentList;
    }

    /**
     * 将获取到的数据，封装到对应的对象中
     * @param list
     * @return  返回部件信息和索引信息
     */
    public static Map<String,Object> getDxfComponent(List<FileComponent> list){

        //判断集合是否为空，为空则返回null值
        if(list==null || list.size()==0){
            return null;
        }

        //创建Map集合，封装处理后的结果
        Map<String,Object> result = new HashMap<>(16);

        //创建索引信息的对象
        DxfDraw titleBar = new DxfDraw();

        //创建部件的集合
        List<DxfComponent> dxfComponentList = new ArrayList<>();

//        int index=1;
        //遍历原始数据，然后进行处理
        for (FileComponent fc : list){

            //声明对象，存储提取到的元素
            DxfComponent dxfObject = new DxfComponent();
            //获取原始数据
            String content = fc.getOriginal();

            //如果当前循环的字符串长度只有一位，那么直接跳过本次循环
            if(content.length()<2){
                continue;
            }
            //定义元件类型
            String typeName = "NA";
            //对数据进行处理
            String subString = handleComponentName(content);

            //保存处理标题栏的数据
            String tb = subString;
            //验证字符串是否是设备信息
            if (handleEquipmentCode(subString)){
                typeName="E";
                dxfObject.setContentC(subString);
            }

            //处理标题栏数据
            if("设备标注文字".equals(fc.getStyle())){

                //对数据进行规则验证，判断是否是图纸编号
                if(tb.startsWith("FQ")  && tb.length()>10){

                    titleBar.setFileCode(tb);
                }else if(handleSystem(tb)){
                    //判断是否是系统值
                    titleBar.setSystem(tb);
                }else if(handleSubItem(tb)){
                    //验证是否是子项值
                    titleBar.setSubitem(tb);
                }else if(handleFileName(tb)){
                    //判断是否是文件名称
                    titleBar.setFileName(tb);
                }else if(handleVersion(tb)){
                    //验证是否是版本
                    titleBar.setVersion(tb);
                }else if(handleEdition(tb)){
                    //验证是否是版次
                    titleBar.setEdition(tb);
                }

            }else{
                //文字类型不是设备标注文字，则数据存放到部件中

                //dxfObject.setId(index);
                //存储部件的类型
                dxfObject.setType(typeName);
                //保存原始数据
                dxfObject.setContentO(content);
                //保存图层数据
                dxfObject.setLayer(fc.getLayer());
                //获取每个点对应的坐标
                dxfObject.setPositionX(fc.getX());
                dxfObject.setPositionY(fc.getY());

                //下标自增
//                index++;

                //将数据放入集合当中
                dxfComponentList.add(dxfObject);
            }
        }

        result.put("dxfObject",dxfComponentList);
        result.put("dxfDraw",titleBar);
        return result;
    }

    /**
     * 数据只保存设备信息
     * @param list
     * @return
     */
    public static Map<String,Object> getDxfComponentEquipment(List<FileComponent> list){

        //判断集合是否为空，为空则返回null值
        if(list==null && list.size()==0){
            return null;
        }

        //创建Map集合，封装处理后的结果
        Map<String,Object> result = new HashMap<>(16);

        //创建索引信息的对象
        DxfDraw titleBar = new DxfDraw();

        //创建部件的集合
        List<DxfComponent> dxfComponentList = new ArrayList<>();

//        int index=1;
        //遍历原始数据，然后进行处理
        for (FileComponent fc : list){

            //声明对象，存储提取到的元素
            DxfComponent dxfObject = new DxfComponent();
            //获取原始数据
            String content = fc.getOriginal();

            //如果当前循环的字符串长度只有一位，那么直接跳过本次循环
            if(content.length()<2){
                continue;
            }

            //对数据进行处理
            String subString = handleComponentName(content);
            System.out.println(subString);
            if(subString.contains("图")){
                System.out.println("11111111111111111111111" + subString);
                titleBar.setFileName(subString);
            }
            //保存处理标题栏的数据
            String tb = subString;
            //验证字符串是否是设备信息
            if (handleEquipmentCode(subString)){
                dxfObject.setContentC(subString);
                //存储部件的类型
                dxfObject.setType("E");
                //保存原始数据
                dxfObject.setContentO(content);
                //保存图层数据
                dxfObject.setLayer(fc.getLayer());
                //获取每个点对应的坐标
                dxfObject.setPositionX(fc.getX());
                dxfObject.setPositionY(fc.getY());

                dxfComponentList.add(dxfObject);

            }else if("设备标注文字".equals(fc.getStyle())){
                //处理标题栏数据

                //对数据进行规则验证，判断是否是图纸编号
                if(tb.startsWith("FQ")  && tb.length()>10){

                    titleBar.setFileCode(tb);
                }else if(handleSystem(tb)){
                    //判断是否是系统值
                    titleBar.setSystem(tb);
                }else if(handleSubItem(tb)){
                    //验证是否是子项值
                    titleBar.setSubitem(tb);
                }else if(handleFileName(tb)){
                    //判断是否是文件名称
                    titleBar.setFileName(tb);
                }else if(handleVersion(tb)){
                    //验证是否是版本
                    titleBar.setVersion(tb);
                }else if(handleEdition(tb)){
                    //验证是否是版次
                    titleBar.setEdition(tb);
                }

            }

        }

        result.put(DrawMapConf.DXF_COMPONENT.value,dxfComponentList);
        result.put(DrawMapConf.DXF_DRAW.value,titleBar);
        return result;
    }


    // 处理读取文件的类型
    private static Boolean readType(String str){
        if("MTEXT".equals(str) || "TEXT".equals(str)){
            return true;
        }
        return false;
    }
    /***
     * 获取部件上的原始数据，然后加工后将数据返回
     * @param origin  原始字符串
     * @return  处理后的字符串
     */
    private static String handleComponentName(String origin){
        //1、以最后一个；为界限，截取子字符串
        if(origin!=null && !"".equals(origin) && origin.contains(";")){
            //获取需要截取的字符串的下标
            int start = origin.lastIndexOf(";")+1;
            int end = origin.lastIndexOf("}");
            if(end==-1){
                //判断是否存在"}"

                //截取到的子字符串
                origin = origin.substring(start);
            }else{
                origin = origin.substring(start,end);
            }
        }
        //将提取数据中的\\P去掉，并去掉所有" "
        origin = origin.replace("\\P","").replaceAll(" ", "");
        return origin;
    }
    /***
     * 验证字符串是否是设备编码
     * @param msg
     * @return
     */
    private static Boolean handleEquipmentCode(String msg){

        //设置正则表达式:以三位数字或四位开头以两位字母结尾或者以三位数字结尾
        String equPattern = "^\\d{3,4}\\s*[a_zA-Z]{2,3}$";
        Pattern equR = Pattern.compile(equPattern);
        Matcher equM = equR.matcher(msg);

        return equM.matches();
    }

    /**
     * 正则表达式，验证是否为系统
     * @param msg
     * @return
     */
    private static Boolean handleSystem(String msg){
        //正则表达式，系统规则验证：三个大写字母
        String pat = "^\\d{0,1}[A-Z]{3}$";
        Pattern rtb = Pattern.compile(pat);
        Matcher mtb = rtb.matcher(msg);

        return mtb.matches();
    }

    /**
     * 封装方法，处理索引的系统信息
     * @param msg 处理的字符串
     * @return 布尔值
     */
    private static Boolean handleSubItem(String msg){
        //定义子项的正则表达式:两个大写字母或者两个大写字母加一个数字
        String subPattern = "^\\d{0,1}[A-Z]{2}$";
        Pattern subR = Pattern.compile(subPattern);
        Matcher subM = subR.matcher(msg);
        return subM.matches();
    }

    /**
     * 处理索引的文件名称
     * @param msg
     * @return
     */
    private static Boolean handleFileName(String msg){
        String companyName = "福建福清";
        //定义图纸名称的正则表达式：大于五个汉字，以后可以含有任意字符
        String namePattern ="[\\u4e00-\\u9fa5]{3,}.*";
        Pattern nameR = Pattern.compile(namePattern);
        Matcher nameM = nameR.matcher(msg);
        if(nameM.matches() && !msg.startsWith(companyName) && msg.length()>=5){
            return true;
        }
        return false;
    }

    /****
     * 处理索引版本信息
     * @param msg
     * @return
     */
    private static Boolean handleVersion(String msg){
        //定义版本的验证规则：三位数字
        String vPattern ="\\d{3}";
        Pattern vR = Pattern.compile(vPattern);
        Matcher vM = vR.matcher(msg);
        return vM.matches();
    }
    /***
     * 处理索引信息版次
     * @param msg
     * @return
     */
    private static Boolean handleEdition(String msg){
        //定义版次的验证规则：两位数字
        String ePattern ="\\d{2}";
        Pattern eR = Pattern.compile(ePattern);
        Matcher eM = eR.matcher(msg);
        return eM.matches();
    }


}
